package com.zelix;

import java.util.*;

public final class ep {

    private static final fp a;
    private static final fp b;
    private static final fp c;
    private ko d;
    private boolean h;
    private nh e;
    private fy f;
    private fy g;
    private fy i;
    private qy j;
    private fy k;
    private fy l;
    private Hashtable m;
    private HashSet n;
    private fy o;
    private static String z[];

    ep(it it1, ht ht1, ko ko1, um um, int i1, boolean flag, nh nh)
            throws qb, bc {
        j = new qy();
        l = new fy();
        m = new Hashtable();
        n = new HashSet();
        o = new fy();
        d = ko1;
        h = flag;
        e = nh;
        k = new fy(i1, 20);
        f = new fy(i1, 50);
        g = new fy(i1, 50);
        i = new fy(101, 37);
        a(it1, ht1);
    }

    public final Object a(String s, dp dp1, lt lt1) {
        return g.b(s, dp1, lt1);
    }

    public final Hashtable a(String s, Hashtable hashtable) {
        return g.a(s, hashtable);
    }

    public final Object b(String s, dp dp1, lt lt1) {
        return f.b(s, dp1, lt1);
    }

    public final Hashtable b(String s, Hashtable hashtable) {
        return f.a(s, hashtable);
    }

    private void a(it it1, ht ht1)
            throws qb, bc {
        Vector vector;
        int i1;
        int j1;
        vector = ht1.i();
        i1 = vector.size();
        for (j1 = 0; j1 < i1; j1++) {
            fh fh1 = (fh) vector.elementAt(j1);
            mt mt = fh1.c();
            String s = mt.j();
            a(s, ((String) (null)));
            fh1.a(this);
        }
        sy sy1;
        fy fy1;
        fy fy2;
        int k1;
        sy1 = new sy();
        fy1 = new fy();
        fy2 = new fy();
        Object obj;
        Object obj3;
        Object obj4;
        for (k1 = 0; k1 < i1; k1++) {
            obj = (fh) vector.elementAt(k1);
            mt mt1 = ((fh) (obj)).c();
            if (mt1.E()) {
                String s1 = mt1.j();
                obj3 = c(s1);
                obj4 = ((Hashtable) (obj3)).keys();
                while (((Enumeration) obj4).hasMoreElements()) {
                    dp dp1 = (dp) ((Enumeration) (obj4)).nextElement();
                    lt lt1 = (lt) ((Hashtable) (obj3)).get(dp1);
                    fh fh4 = fh.b(lt1.j());
                    if (fh4 != null && fh4.w()) {
                        sy1.b(dp1, fh4, obj);
                    } else {
                        fy2.b(obj, dp1, lt1);
                    }
                }
                Vector vector1 = new Vector();
                j.a(obj, vector1);
                a(((fh) (obj)), ((fh) (obj)), true, vector1, fy1);
                fy1.b(obj, obj, "s");
            }
        }

        obj = sy1.b();
        Object obj1;
        Object obj2;
        Object obj5;
        while (((Enumeration) obj).hasMoreElements()) {

            obj1 = (dp) ((Enumeration) (obj)).nextElement();
            obj2 = sy1.b(obj1);
            obj3 = new Vector();
            obj4 = ((qy) (obj2)).e();
            while (((Enumeration) obj4).hasMoreElements()) {
                fh fh2 = (fh) ((Enumeration) (obj4)).nextElement();
                qx qx1 = new qx();
                a(qx1, fh2, ((qy) (obj2)));
                ((Vector) (obj3)).addElement(qx1);
            }
            obj4 = ((qy) (obj2)).e();
            Object obj6;
            Object obj8;
            Object obj9;
            while (((Enumeration) obj4).hasMoreElements()) {
                fh fh3;

                int i2;
                fh3 = (fh) ((Enumeration) (obj4)).nextElement();
                obj5 = (Vector) ((Vector) (obj3)).clone();
                obj6 = null;
                for (i2 = 0; i2 < ((Vector) obj5).size(); i2++) {

                    obj8 = (qx) ((Vector) (obj5)).elementAt(i2);
                    if (((qx) (obj8)).a(fh3)) {
                        if (obj6 == null) {
                            obj6 = obj8;
                        } else {
                            obj9 = ((qx) (obj8)).a();
                            while (((Enumeration) obj9).hasMoreElements()) {
                                Object obj10 = ((Enumeration) (obj9)).nextElement();
                                ((qx) (obj6)).a(obj10, obj10);
                            }
                            boolean flag = ((Vector) (obj3)).removeElement(obj8);
                        }
                    }
                }
            }
            for (int l1 = 0; l1 < ((Vector) obj3).size(); l1++) {
                wu wu1;
                obj5 = (qx) ((Vector) (obj3)).elementAt(l1);
                obj6 = new Vector(((qx) (obj5)).b());
                wu1 = new wu(obj6);
                m.put(wu1, new wu());
                obj8 = ((qx) (obj5)).a();
                while (((Enumeration) (obj8)).hasMoreElements()) {
                    obj9 = (fh) ((Enumeration) (obj8)).nextElement();
                    ((Vector) (obj6)).addElement(obj9);
                    l.b(obj9, obj1, wu1);
                }

                int j2;
                obj9 = null;
                for (j2 = 0; j2 < ((Vector) (obj6)).size(); j2++) {
                    fh fh5 = (fh) ((Vector) (obj6)).elementAt(j2);
                    lt lt2 = (lt) fy2.b(fh5, obj1);
                    if (lt2 != null) {
                        obj9 = lt2;
                        break;
                    }
                }

                int k2;
                if (obj9 == null) {
                    for (k2 = 0; k2 < ((Vector) (obj6)).size(); k2++) {
                        fh fh6 = (fh) ((Vector) (obj6)).elementAt(k2);
                        mt mt2 = fh6.c();
                        if (it1.a(((dp) (obj1)), mt2)) {
                            obj9 = mt2;
                            break;
                        }
                    }
                }
                lx.b(obj9, z[4] + obj1 + " " + obj6);
                for (k2 = 0; k2 < ((Vector) (obj6)).size(); k2++) {
                    fh fh7 = (fh) ((Vector) (obj6)).elementAt(k2);
                    i.b(fh7.d(), obj1, obj9);
                }
            }
        }


        obj1 = fy1.e();
        while (((Enumeration) (obj1)).hasMoreElements()) {
            obj2 = (Hashtable) ((Enumeration) (obj1)).nextElement();
            if (((Hashtable) (obj2)).size() <= 1)
                continue; /* Loop/switch isn't completed */
            obj3 = ((Hashtable) (obj2)).keys();
            while (((Enumeration) (obj3)).hasMoreElements()) {
                obj4 = ((Enumeration) (obj3)).nextElement();
                String s2 = (String) ((Hashtable) (obj2)).get(obj4);
                if (s2.equals("d"))
                    continue; /* Loop/switch isn't completed */
                obj5 = ((Hashtable) (obj2)).keys();
                while (((Enumeration) (obj5)).hasMoreElements()) {
                    Object obj7 = ((Enumeration) (obj5)).nextElement();
                    if (obj4 != obj7)
                        o.b(obj4, obj7, obj7);
                }
            }
        }
    }

    public final Vector a(fh fh1) {
        return j.d(fh1);
    }

    public final Hashtable a(String s, String s1)
            throws qb, bc {
        Hashtable hashtable;
        Object obj;
        fh fh1 = fh.b(s);
        boolean flag = fh1 != null && fh1.w();
        hashtable = d(s);
        if (hashtable == null) {
            if (!flag) {
                obj = b(s);
            } else
                obj = fh1.c();
            hashtable = ((lt) (obj)).a(this);
        }
        return hashtable;
    }

    final nt b(String s)
            throws bc {
        try {
            nt nt = d.a(s);
            return nt;
        }
        catch (xb xb1) {
            throw new bc(z[0] + lt.a(xb1.a()) + z[1]);
        }
        catch (wb wb1) {
            throw new bc(wb1.getMessage());
        }
    }

    private Hashtable c(String s) {
        return g.b(s);
    }

    private Hashtable d(String s) {
        return f.b(s);
    }

    public final lt a(String s, dp dp1) {
        HashSet hashset;
        lt lt1;
        lt lt2;
        hashset = null;
        lt1 = (lt) g.b(s, dp1);
        lt2 = null;
        while (lt1 != null) {
            StringBuffer stringbuffer;
            Iterator iterator;
            lt2 = lt1;
            lt1 = (lt) g.b(lt1.j(), dp1);
            if (lt1 == null)
                continue; /* Loop/switch isn't completed */
            if (hashset == null)
                hashset = new HashSet(13);
            if (hashset.add(lt1))
                continue; /* Loop/switch isn't completed */
            stringbuffer = new StringBuffer();
            iterator = hashset.iterator();
            while (iterator.hasNext()) {
                lt lt3 = (lt) iterator.next();
                stringbuffer.append("'" + lt3.j() + "'");
                if (iterator.hasNext())
                    stringbuffer.append(z[3]);
            }
            lx.b(false, z[2] + dp1 + zo.e + stringbuffer);
        }
        return lt2;
    }

    public final String a(wu wu1) {
        return (String) ((wu) m.get(wu1)).a();
    }

    Hashtable a() {
        Hashtable hashtable;
        Enumeration enumeration;
        hashtable = new Hashtable();
        enumeration = l.d();
        while (enumeration.hasMoreElements()) {
            Hashtable hashtable1;
            Enumeration enumeration1;
            fh fh1 = (fh) enumeration.nextElement();
            hashtable1 = l.b(fh1);
            enumeration1 = hashtable1.keys();
            while (enumeration1.hasMoreElements()) {
                dp dp1 = (dp) enumeration1.nextElement();
                wu wu1 = (wu) hashtable1.get(dp1);
                Object obj = hashtable.put(wu1, dp1);
            }
        }
        return hashtable;
    }

    final wu a(fh fh1, dp dp1) {
        return (wu) l.b(fh1, dp1);
    }

    public final lt b(String s, dp dp1) {
        lt lt1 = (lt) i.b(s, dp1);
        if (lt1 != null)
            return lt1;
        lt1 = (lt) g.b(s, dp1);
        lt lt2 = null;
        for (; lt1 != null; lt1 = (lt) g.b(lt1.j(), dp1)) {
            lt2 = lt1;
            lt lt3 = (lt) i.b(lt1.j(), dp1);
            if (lt3 != null)
                return lt3;
        }

        return lt2;
    }

    public final void a(dp dp1) {
        Object obj;
        if (h) {
            obj = dp1;
        } else
            obj = dp1.a();
        n.add(obj);
    }

    public final boolean b(dp dp1) {
        Object obj;
        if (h) {
            obj = dp1;
        } else
            obj = dp1.a();
        return n.contains(obj);
    }

    private boolean c(String s, dp dp1) {
        return g.a(s, dp1);
    }

    public final boolean b(fh fh1, dp dp1) {
        Object obj;
        if (h) {
            obj = dp1;
        } else
            obj = dp1.a();
        return k.a(fh1, obj);
    }

    public final boolean a(fh fh1, dp dp1, dp dp2) {
        Object obj;
        Object obj1;
        if (h) {
            obj = dp2;
            obj1 = dp1;
        } else {
            obj = dp2.a();
            obj1 = dp1.a();
        }
        fp fp1 = (fp) k.b(fh1, obj1);
        if (fp1 == null)
            return false;
        else
            return fp1.a.equals(obj) ^ true;
    }

    private void a(qx qx1, fh fh1, qy qy1) {
        Vector vector;
        Object obj = qx1.a(fh1, fh1);
        if (obj != null)
            return;
        vector = qy1.d(fh1);
        if (vector != null) {
            for (int i1 = 0; i1 < vector.size(); i1++) {
                fh fh2 = (fh) vector.elementAt(i1);
                a(qx1, fh2, qy1);
            }
        }
    }

    final void a(fh fh1, fh fh2, boolean flag, Vector vector, fy fy1) {
        Object obj;
        if (flag && !fh2.v()) {
            int i1;
            flag = false;
            obj = new Vector(5);
            fh2.a(((Vector) (obj)));
            for (i1 = 0; i1 < ((Vector) obj).size(); i1++) {
                fh fh4 = (fh) ((Vector) (obj)).elementAt(i1);
                if (fy1.a(fh4, fh1))
                    break;
                fy1.b(fh4, fh1, "d");
                vector.addElement(fh4);
            }
        }

//_L2:
        obj = fh2.p();
        if (obj != null) {
            while (((Enumeration) obj).hasMoreElements()) {
                fh fh3 = (fh) ((Enumeration) (obj)).nextElement();
                fy1.b(fh3, fh1, "i");
                a(fh1, fh3, flag, vector, fy1);
                vector.addElement(fh3);
            }
        }
//_L6:
        Enumeration enumeration = fh2.l();
        if (enumeration != null) {
            while (enumeration.hasMoreElements()) {
                fh fh5 = (fh) enumeration.nextElement();
                fy1.b(fh5, fh1, "i");
                a(fh1, fh5, flag, vector, fy1);
                if (!fh5.v())
                    vector.addElement(fh5);
            }
        }
    }

    private void a(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1) {
        Object obj;
        int i1;
        wu wu1 = a(fh1, new dp(m5_2));
        if (wu1 != null) {
            obj = (Vector) wu1.a();
            for (i1 = 0; i1 < ((Vector) obj).size(); i1++) {
                fh fh3 = (fh) ((Vector) (obj)).elementAt(i1);
                Object obj1 = hashtable.put(fh3, fh3);
            }
        } else {
            obj = hashtable.put(fh1, fh1);
            obj = hashtable.keys();
            while (((Enumeration) obj).hasMoreElements()) {
                fh fh2 = (fh) ((Enumeration) (obj)).nextElement();
                a(fh2, hashtable1);
            }
        }
    }

    private boolean a(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1, Hashtable hashtable2, ou ou) {
        int i1;
        if (ou.A()) {
            i1 = a(fh1, m5_1);
        } else if (ou.D()) {
            i1 = b(fh1, m5_1);
        } else {
            i1 = a(fh1, m5_1, m5_2);
        }
        switch (i1) {
            case -1:
                a(hashtable, hashtable1, m5_1);
                return false;

            case 0: // '\0'
                hashtable.put(fh1, fh1);
                // fall through
                break;
            case 1: // '\001'
            case 2: // '\002'
            default:
                fh1.b(hashtable2);
                break;
        }
        if (!ou.A() && !ou.D()) {
            Enumeration enumeration = fh1.p();
            if (enumeration != null) {
                while (enumeration.hasMoreElements()) {
                    fh fh2 = (fh) enumeration.nextElement();
                    if (!a(fh2, m5_1, m5_2, hashtable, hashtable1, hashtable2, ou))
                        return false;
                }
            }
        }
        return true;
    }

    private boolean b(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1, Hashtable hashtable2, ou ou) {
        fh fh2;
        int i1;
        fh2 = fh1.q();
        if (fh2 != null) {
            if (ou.A()) {
                i1 = a(fh2, m5_1);
            } else if (ou.D()) {
                i1 = b(fh2, m5_1);
            } else
                i1 = a(fh2, m5_1, m5_2, hashtable1);
            switch (i1) {
                default:
                    break;

                case -1:
                    a(hashtable, hashtable1, m5_1);
                    return false;

                case 0: // '\0'
                    hashtable.put(fh2, fh2);
                    break;
                    // fall through

                case 1: // '\001'
                case 2: // '\002'
                    return true;
            }
            fh2.b(hashtable2);
            if (!b(fh2, m5_1, m5_2, hashtable, hashtable1, hashtable2, ou))
                return false;
        }
        return true;
    }

    private void a(fh fh1, Hashtable hashtable) {
        Hashtable hashtable1;
        hashtable1 = o.b(fh1);
        if (hashtable1 != null) {
            Enumeration enumeration = hashtable1.keys();
            while (enumeration.hasMoreElements()) {
                fh fh2 = (fh) enumeration.nextElement();
                hashtable.put(fh2, fh2);
            }
        }
    }

    private boolean b(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1) {
        int i1 = a(fh1, m5_1, m5_2, hashtable1);
        switch (i1) {
            case -1:
                a(hashtable, hashtable1, m5_1);
                return false;

            case 0: // '\0'
                hashtable.put(fh1, fh1);
                // fall through

            case 1: // '\001'
            case 2: // '\002'
            default:
                return true;
        }
    }

    final boolean b(fh fh1, dp dp1, dp dp2) {
        Object obj;
        Object obj1;
        Hashtable hashtable1;
        Hashtable hashtable2;
        Hashtable hashtable3;
        Enumeration enumeration;
        boolean flag;
        if (h) {
            obj = dp1;
            obj1 = dp2;
        } else {
            obj = dp1.a();
            obj1 = dp2.a();
        }
        Hashtable hashtable = new Hashtable();
        hashtable1 = new Hashtable();
        a(fh1, ((m5) (obj)), ((m5) (obj1)), hashtable, hashtable1);
        hashtable2 = new Hashtable(px.a(hashtable.size() + hashtable1.size()));
        hashtable3 = new Hashtable();
        enumeration = hashtable.keys();
        while (enumeration.hasMoreElements()) {
            fh fh2 = (fh) enumeration.nextElement();
            int i1 = a(fh2, ((m5) (obj)), ((m5) (obj1)));
            switch (i1) {
                case -1:
                    a(hashtable2, hashtable3, ((m5) (obj)));
                    return false;

                case 0: // '\0'
                    hashtable2.put(fh2, fh2);
                    break;
            }
            if (!c(fh2, ((m5) (obj)), ((m5) (obj1)), hashtable2, hashtable3))
                return false;
        }
        Enumeration enumeration1 = hashtable1.keys();
        while (enumeration1.hasMoreElements()) {
            fh fh3 = (fh) enumeration1.nextElement();
            int j1 = a(fh3, ((m5) (obj)), ((m5) (obj1)), hashtable3);
            switch (j1) {
                case -1:
                    a(hashtable2, hashtable3, ((m5) (obj)));
                    return false;

                case 0: // '\0'
                    hashtable2.put(fh3, fh3);
                    break;
            }
        }
        return true;
    }

    final boolean a(fh fh1, dp dp1, dp dp2, ou ou) {
        Object obj;
        Object obj1;
        Hashtable hashtable;
        Hashtable hashtable1;
        Enumeration enumeration;
        if (h) {
            obj = dp1;
            obj1 = dp2;
        } else {
            obj = dp1.a();
            obj1 = dp2.a();
        }
        Hashtable hashtable2;
        boolean flag;
        hashtable = new Hashtable();
        hashtable1 = new Hashtable();
        hashtable2 = new Hashtable(17);
        flag = a(fh1, ((m5) (obj)), ((m5) (obj1)), hashtable, hashtable1, hashtable2, ou);
        if (flag) {
            flag = b(fh1, ((m5) (obj)), ((m5) (obj1)), hashtable, hashtable1, hashtable2, ou);
        } else {
            return false;
        }
        if (flag) {
            enumeration = hashtable2.keys();
            while (enumeration.hasMoreElements()) {
                fh fh2 = (fh) enumeration.nextElement();
                if (!b(fh2, ((m5) (obj)), ((m5) (obj1)), hashtable, hashtable1))
                    return false;
            }
        } else {
            return false;
        }
        return true;
    }

    private int a(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable) {
        if (!fh1.w())
            return 2;
        fp fp1 = (fp) k.b(fh1, m5_1, a);
        if (fp1 == null)
            return 0;
        if (fp1 == c || fp1 == b) {
            gp gp1 = new gp(fh1, fp1);
            hashtable.put(gp1, gp1);
            return 0;
        }
        if (fp1 == a)
            return 1;
        if (fp1.a != null && fp1.a.equals(m5_2)) {
            k.b(fh1, m5_1, fp1);
            return 1;
        } else {
            k.b(fh1, m5_1, fp1);
            return -1;
        }
    }

    private int a(fh fh1, m5 m5_1) {
        if (!fh1.w())
            return 2;
        fp fp1 = (fp) k.b(fh1, m5_1, c);
        if (fp1 == null)
            return 0;
        if (fp1 == c)
            return 1;
        if (fp1 == b) {
            k.b(fh1, m5_1, fp1);
            return 1;
        }
        if (fp1 == a) {
            k.b(fh1, m5_1, a);
            return 1;
        }
        if (fp1.a != null && fp1.b == 3) {
            k.b(fh1, m5_1, fp1);
            return 1;
        } else {
            k.b(fh1, m5_1, fp1);
            return -1;
        }
    }

    private int b(fh fh1, m5 m5_1) {
        if (!fh1.w())
            return 2;
        fp fp1 = (fp) k.b(fh1, m5_1, b);
        if (fp1 == null)
            return 0;
        if (fp1 == c) {
            k.b(fh1, m5_1, fp1);
            return 1;
        }
        if (fp1 == b)
            return 1;
        if (fp1 == a) {
            k.b(fh1, m5_1, a);
            return 1;
        } else {
            k.b(fh1, m5_1, fp1);
            return -1;
        }
    }

    private int a(fh fh1, m5 m5_1, m5 m5_2) {
        if (!fh1.w())
            return 2;
        fp fp1 = (fp) k.b(fh1, m5_1, new fp(m5_2));
        if (fp1 == null)
            return 0;
        if (fp1.a != null && fp1.a.equals(m5_2)) {
            return 1;
        } else {
            k.b(fh1, m5_1, fp1);
            return -1;
        }
    }

    private boolean c(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1) {
        Vector vector;
        vector = a(fh1);
        if (vector != null) {
            for (int i1 = 0; i1 < vector.size(); i1++) {
                int j1;
                fh fh2 = (fh) vector.elementAt(i1);
                if (c(fh2.d(), new dp(m5_2))) {
                    j1 = a(fh2, m5_1, m5_2);
                } else
                    j1 = a(fh2, m5_1, m5_2, hashtable1);
                switch (j1) {
                    case -1:
                        a(hashtable, hashtable1, m5_1);
                        return false;

                    case 0: // '\0'
                        hashtable.put(fh1, fh1);
                        break;
                }
            }
        }
        return true;
    }

    final boolean a(wu wu1, dp dp1, dp dp2) {
        Vector vector;
        Object obj;
        Object obj1;
        Hashtable hashtable;
        Hashtable hashtable1;
        int i1;
        vector = (Vector) wu1.a();
        if (h) {
            obj = dp1;
            obj1 = dp2;
        } else {
            obj = dp1.a();
            obj1 = dp2.a();
        }
        hashtable = new Hashtable();
        hashtable1 = new Hashtable();
        for (i1 = 0; i1 < vector.size(); i1++) {
            fh fh1 = (fh) vector.elementAt(i1);
            int j1 = a(fh1, ((m5) (obj)), ((m5) (obj1)));
            switch (j1) {
                case -1:
                    a(hashtable, hashtable1, ((m5) (obj)));
                    return false;

                case 0: // '\0'
                    hashtable.put(fh1, fh1);
                    break;
            }
        }
        a(wu1, ((m5) (obj)).c());
        return true;
    }

    private void a(Hashtable hashtable, Hashtable hashtable1, m5 m5_1) {
        Enumeration enumeration;
        enumeration = hashtable.keys();
        while (enumeration.hasMoreElements()) {
            Object obj = enumeration.nextElement();
            Object obj1 = k.c(obj, m5_1);
        }
//_L3:
        Enumeration enumeration1 = hashtable1.keys();
        while (enumeration1.hasMoreElements()) {
            gp gp1 = (gp) enumeration1.nextElement();
            Object obj2 = k.b(gp1.a, m5_1, gp1.b);
        }
    }

    public final void a(wu wu1, String s) {
        wu wu2 = (wu) m.get(wu1);
        wu2.a(s);
    }

    private static String z(char[] chs) {
        byte key = 0;
        for (int i = 0; i < chs.length; i++) {
            switch (i % 5) {
                case 0:
                    key = 24;
                    break;
                case 1:
                    key = 55;
                    break;
                case 2:
                    key = 57;
                    break;
                case 3:
                    key = 21;
                    break;
                case 4:
                    key = 77;
                    break;
            }
            chs[i] ^= key;
        }
        return new String(chs).intern();
    }

    static {
        String as[];
        as = new String[5];
        as[0] = z("g[Xf>\004\020".toCharArray());
        as[1] = z("\003\027Wz9\004QV`#@\031\031=|\r".toCharArray());
        as[2] = z("hxvEm@RMp.PR];c\n".toCharArray());
        as[3] = z("\b\027".toCharArray());
        as[4] = z("bVPy(@\027MzmB^Wqm@R\\x(@\027]p9AET|#MY^5$JC\\g+ET\\5".toCharArray());
        z = as;
        a = new fp(1);
        b = new fp(2);
        c = new fp(3);
    }
}